import java.util.Arrays;
import java.util.Stack;

public class TestG {

    public int lengthOfLongestSubstring(String s) {
        int n = s.length();
        int right = 0;
        int left = 0;
        int count = Integer.MIN_VALUE ;
        int[] hash = new int[128];
        char[] ss = s.toCharArray();
        while (right < n) {

            hash[ss[right]] ++ ;
            while(hash[ss[right]] > 1) {
                hash[ss[left++]]--;
            }
            count = Math.max(count,right - left + 1);
            right ++ ;
        }
        return count == Integer.MIN_VALUE ? 0 : count;
    }
//    public int missingNumber(int[] nums) {
//        int n = nums.length;
//        int sum = 0;
//        int otherSum = 0;
//        for (int i = 0; i <= n; i++) {
//            sum += i;
//        }
//
//        for (int i = 0; i < nums.length; i++) {
//            otherSum += nums[i];
//        }
//
//        return sum - otherSum > 0 ? sum - otherSum : -1;
//
//    }

//    public static int minSubArrayLen(int target, int[] nums) {
//
//        // 双指针遍历整个数组
//
//
//
//        int sum = 0;
//        int min = Integer.MAX_VALUE;
//
//        for (int right = 0,left = 0; right < nums.length; right++) {
//            sum += nums[right];
//
//            while (sum >= target) {
//                min = Math.min(right - left + 1,min);
//                sum -= nums[left++];
//            }
//
//        }
//        return min == Integer.MAX_VALUE ? 0 : min;
//    }
//
//
//    public static void main(String[] args) {
//        int[] arr = new int[]{1,2,3,4,5};
//        System.out.println(arr.length);
//        int target = 11;
//        int arrNum = minSubArrayLen(target,arr);
//        System.out.println(arrNum);
//    }

//    public static int minSubArrayLen(int target, int[] nums) {
//
//        // 双指针遍历整个数组
//        // 当两指针相遇时判断 当前值是否为target
//        // 如果为target则返回 1
//        // 如果不为target则将当前数值保存在sum中 并且让last指针向前走一步，并且判断当前指针 + sum 是否为target
//        // 如果大于target则让first指针想前走一步 并且在走之前将sum中的值减去当前first值
//        // 再次判断是否为target
//        // 如果小于target则让last指针想前走一步 并且判断当前指针 + sum 是否为target
//        // 如果等于target则记录当前两指针的距离+1
//        // 再次将first指针向前走 并且在走之前将sum中的值减去当前first值
//        // 重复判断直到 first到末尾 每次进入循环请首先判断last是否在末尾，如果在末尾则直接让first++
//
//        Arrays.sort(nums);
//
//
//        int first = 0;
//        int last = 0;
//        int sum = 0;
//        int min = Integer.MAX_VALUE;
//
//        while(first <= nums.length - 1) {
//
//            if(last == nums.length - 1 && first < last) {
//                return 0;
//            }
//            if(first == last) {
//
//                sum = 0;
//
//                if (nums[first] == nums[last] && nums[first] == target) {
//                    return 1;
//                }
//
//                if(nums[first] == nums[last] && nums[first] > target) {
//                    return 0;
//                }
//
//
//                if(first == last && first == nums.length - 1) {
//                    return min;
//                }
//
//                last ++ ;
//                if(last >= nums.length) {
//                    last = nums.length - 1;
//                }
//
//                sum += nums[first];
//                continue;
//            }
//
//            if(sum + nums[last] == target) {
//                min = Math.min(last - first + 1, min);
//                first ++ ;
//                continue;
//            }
//
//            if(sum + nums[last] > target) {
//                sum -= nums[first];
//                first ++ ;
//                continue;
//            }
//
//            if(sum + nums[last] < target) {
//                sum += nums[last];
//                last ++ ;
//            }
//
//            if(last >= nums.length) {
//                last = nums.length - 1;
//                first ++ ;
//            }
//
//        }
//
//        return min;
//    }

//    public static void main(String[] args) {
//
//        String userId = "123";
//
//        Long id = Long.parseLong(userId);
//        System.out.println(id);
//
//        for (int i = 0; i < 10; i++) {
//            int ret = (i + 1) % 10;
//            System.out.println(ret);
//        }
//        System.out.println();
//        String receiveUserId = "123你好";
//
//        Integer ruid = Integer.valueOf(receiveUserId);
//
//        System.out.println(ruid);
//
//    }

//    public boolean IsPopOrder (int[] pushV, int[] popV) {
//        Stack<Integer> stack = new Stack<>();
//
//        int j = 0;
//        for (int i = 0; i < pushV.length; i++) {
//            stack.push(pushV[i]);
//            while(j < popV.length && !stack.isEmpty() && stack.peek().equals(popV[j])) {
//                stack.pop();
//                j++;
//            }
//        }
//        return stack.isEmpty();
//    }

//    public boolean IsPopOrder (int[] pushV, int[] popV) {
//        // write code here
//        int pushIndex = 0;
//        int popIndex = 0;
//        int num = pushV.length;
//        Stack<Integer> stack = new Stack<>();
//
//        if (num == 0) {
//            return true;
//        }
//
//        while (num > 0) {
//
//            if(pushV[pushIndex] != popV[popIndex]) {
//                stack.push(pushV[pushIndex]);
//                pushIndex++;
//                popIndex++;
//                num--;
//            }else {
//                if(popV.length != 0 && !stack.isEmpty()) {
//                    pushIndex++;
//                    popIndex++;
//                }
//            }
//        }
//
//        if(num == 0 && stack.isEmpty()) {
//            return true;
//        }
//        return false;
//    }

//    public boolean isValid(String s) {
//        //遍历字符串
//        //将每一位左括号入栈
//        //遇到右括号则出栈匹配
//        //如果匹配不成功则返回false
//        //当栈为空，字符串未遍历完则false
//        //字符串遍历完，而栈不为空则false
//
//        char[] chars = s.toCharArray();
//        Stack<Character> stack = new Stack<>();
//        for (int i = 0; i < chars.length; i++) {
//
//            if (isLeft(chars[i])) {
//                stack.push(chars[i]);
//            }else {
//                if(stack.isEmpty()) {
//                    return false;
//                }
//                char chLeft = stack.peek();
//                if(chLeft == '(' && chars[i] == ')' || chLeft == '{' && chars[i] == '}' || chLeft == '[' && chars[i] == ']') {
//                    stack.pop();
//                }else {
//                    return false;
//                }
//            }
//        }
//        if(!stack.isEmpty()) {
//            return false;
//        }
//        return true;
//    }
//    public boolean isLeft(char ch) {
//        if(ch == '(' || ch == '{' || ch == '[') {
//            return true;
//        }
//        return false;
//    }

//    public int evalRPN(String[] tokens) {
//
//
//        //遍历数组
//        //遇到数字，进栈，
//        //遇到运算符，将数字出栈的作为num2，后出栈的为num1
//        //根据运算符匹配相应的运算方法
//        //计算结果入栈
//
//        Stack<Integer> stack = new Stack<>();
//
//        for (int i = 0; i < tokens.length; i++) {
//            String token = tokens[i];
//
//            if(isNum(token)) {
//                stack.push(Integer.parseInt(token));
//            }else {
//                int num2 = stack.pop();
//                int num1 = stack.pop();
//                switch (token) {
//                    case "+" :
//                        stack.push(num1 + num2);
//                        break;
//                    case "-" :
//                        stack.push(num1 - num2);
//                        break;
//
//                    case "*" :
//                        stack.push(num1 * num2);
//                        break;
//
//                    case "/" :
//                        stack.push(num1 / num2);
//                        break;
//                    default:
//                }
//            }
//        }
//
//        return stack.pop();
//
//
//    }
//    public boolean isNum(String token) {
//
//        if("+".equals(token) || "-".equals(token) || "*".equals(token) || "/".equals(token)) {
//            return false;
//        }
//        return true;
//    }
}
